

<table border>
  <tr>
    <th>Fichier</th>
    <th>Classe(s) d&eacute;finie(s)</th>
    <th>Description</th>
  </tr>



  <tr>
    <td><a href="Point2D.java">Point2D.java</a></td>
    <td>Point2D</td>
    <td rowspan=3>Des classes de nature math&eacute;matique / g&eacute;om&eacute;trique</td>
  </tr>
  <tr>
    <td><a href="Vector2D.java">Vector2D.java</a></td>
    <td>Vector2D</td>
  </tr>
  <tr>
    <td><a href="AlignedRectangle2D.java">AlignedRectangle2D.java</a></td>
    <td>AlignedRectangle2D</td>
  </tr>



  <tr>
    <td><a href="Point2DUtil.java">Point2DUtil.java</a></td>
    <td>Point2DUtil</td>
    <td>Une classe contenant des m&eacute;thodes
       pour tester si un point est &agrave; l'int&eacute;rieur
       d'un polygone (utile pour r&eacute;aliser des effets de surbrilliance,
       et pour r&eacute;aliser la s&eacute;lection en lasso),
       pour calculer l'enveloppe convexe d'un ensemble de points
       (utile pour dessiner des "bulles" autour d'un ou plusieurs objets),
       et pour transformer un ensemble de points selon le d&eacute;placement
       d'un ou deux doigts (utile dans les interfaces multitactiles).
    </td>
  </tr>



  <tr>
    <td><a href="GraphicsWrapper.java">GraphicsWrapper.java</a></td>
    <td>GraphicsWrapper</td>
    <td>Une classe qui facilite le dessin en 2D.
        Il y a deux int&eacute;r&ecirc;ts &agrave; utiliser cette classe:
        d'abord, elle facilite la gestion de zoom et pan dans une vue 2D
        (transformation entre les syst&egrave;mes de coordonn&eacute;es "pixels" et "espace monde"
        au moment du dessin et au moment de la r&eacute;ception d'&eacute;v&eacute;nements
        de souris).
        Deuxi&egrave;mement, l'implementation qui vous est fournie
        utilise OpenGL pour dessiner,
        mais on pourrait &eacute;ventuellement changer cette implementation pour
        une autre version qui utilise Java2D/Graphics2D pour dessiner,
        ce qui permettrait de d&eacute;ployer le code sous forme d'Applet sur le web
        (si on enlevait les aspects multitactiles du code client).
        <br/>
        <br/>
        Pour compiler et ex&eacute;cuter
        le code, vous avez besoin de la librarie JOGL.
        Une copie se trouve au
        <a href="http://profs.etsmtl.ca/mmcguffin/code/java/lib/JOGL/">http://profs.etsmtl.ca/mmcguffin/code/java/lib/JOGL/</a>

        </td>
  </tr>


  <tr>
    <td><a href="Constant.java">Constant.java</a></td>
    <td>Constant</td>
    <td>Quelques constantes.
        <br/>
        <br/>
        Changez NUM_ARMIES pour changer le nombre d'arm&eacute;es.
        </td>
  </tr>



  <tr>
    <td><a href="org/mt4j/input/inputSources/Win7NativeTouchSource.java">org/mt4j/input/inputSources/Win7NativeTouchSource.java</a></td>
    <td>Win7NativeTouchSource, Native_WM_TOUCH_Event</td>
    <td>Une classe tir&eacute;e de la librarie MT4j.
        Le chemin relatif vers cette classe ne doit pas changer,
        car elle utilise un .DLL (Win7Touch.dll) qui
        s'attend &agrave; communiquez avec la classe Java.org.mt4j.input.inputSources.Win7NativeTouchSource
        <br/>
        <br/>
        Cette classe a seulement besoin d'&ecirc;tre compil&eacute;e si vous voulez utiliser WM_TOUCH
        pour recevoir les &eacute;v&eacute;nements multitactiles.
        Elle est utilis&eacute;e par la version WM_TOUCH du MultitouchFramework
        (MultitouchFramework-WM_TOUCH.java)
        </td>
  </tr>


  <tr>
    <td><a href="MultitouchFramework.java">MultitouchFramework.java</a></td>
    <td>MultitouchFramework</td>
    <td>Un cadriciel qui re&ccedil;oit les &eacute;v&eacute;nements multitactiles
        (soit via TUIO, ou WM_TOUCH, ou de la souris permettant de simuler
        plusieurs points de contact) et ensuite appelle des m&eacute;thodes
        dans le code client.
        Ce fichier contient le point d'entr&eacute;e main().
        Il y a trois versions de ce fichier, dans le r&eacute;pertoire "doNotCompile":
        MultitouchFramework-MOUSE.java, MultitouchFramework-TUIO.java, et MultitouchFramework-WM_TOUCH.java.
        Copiez une de ces versions par dessus le fichier MultitouchFramework.java,
        en changeant le nom de fichier, avant de compiler.
        <b>Ne modifiez pas votre copie de MultitouchFramework.java, car ces modifications pourront
        &ecirc;tre perdus, brisant votre code,
        lorsque vous copiez une autre version par dessus.</b>
        La version "-MOUSE" est utile pour travailler hors du laboratoire,
        quand vous n'avez pas acc&egrave;s &agrave; un dispositif multitactile,
        car elle permet de simuler un ou plusieurs doigts avec la souris.
        La version "-WM_TOUCH" n&eacute;cessite de compiler avec quelques fichiers tir&eacute;s de la librarie MT4j,
        et aussi org/mt4j/input/inputSources/Win7NativeTouchSource.java,
        et fonctionne seulement sur MS Windows 7.
        La version "-TUIO" n&eacute;cessite de compiler avec la librarie libTUIO.jar.
        <br/>
        <br/>
        Pour compiler et ex&eacute;cuter la version "-WM_TOUCH",
        le fichiers n&eacute;cessaires de MT4j
        se trouvent au
        <a href="http://profs.etsmtl.ca/mmcguffin/code/java/lib/MT4j/">http://profs.etsmtl.ca/mmcguffin/code/java/lib/MT4j/</a>
        <br/>
        <br/>
        Quand vous utilisez la version "-MOUSE",
        pour simuler un seul doigt,
        faites Ctrl+bouton droit (appuyer, glisser, rel&acirc;cher).
        Pour simuler plusieurs doigts, faites Ctrl-bouton gauche (appuyer, glisser, rel&acirc;cher;
        plusieurs fois si vous voulez)
        pour chaque doigt que vous voulez simuler,
        ensuite pour faire rel&acirc;cher un doigt virtuel faites Ctrl+bouton droit
        sur le curseur du doigt.
        En r&eacute;sum&eacute;:<br/>
        <b>Ctrl-clic gauche</b> simule un doigt qui appuie et glisse et reste appuy&eacute;,<br/>
        <b>Ctrl-clic droit</b> simule un doigt qui appuie et glisse et rel&acirc;che.

        <br/>
        </td>
  </tr>




  <tr>
    <td><a href="SimpleMultitouchRealTimeStrategyGame.java">SimpleMultitouchRealTimeStrategyGame.java</a></td>
    <td>Soldier, Army, Game, MyCursor, MyCursorContainer, SimpleMultitouchRealTimeStrategyGame</td>
    <td>Les classes principales.
        SimpleMultitouchRealTimeStrategyGame est le client de MultitouchFramework.
        <br/>
        <br/>
        Pour d&eacute;placer des soldats, faites un geste de lasso
        pour encercler les soldats &agrave; d&eacute;placer,
        ensuite faites un glissement de l'int&eacute;rieur de la bulle de s&eacute;lection
        vers la destination.
        <br/>
        <br/>
        Dans le code, cherchez la cha&icirc;ne "sleep" pour voir comment changer le taux de rafra&icirc;chissement.
        <br/>
        <br/>
        La derni&egrave;re m&eacute;thode dans ce fichier, processMultitouchInputEvent(),
        est appell&eacute;e quand un doigt (simul&eacute; ou non) appuie, glisse, ou rel&acirc;che.
        Chaque doigt est assign&eacute; un identifiant unique (un entier).
        Les param&egrave;tres &agrave; la m&eacute;thode processMultitouchInputEvent() sont<br/>
        int id : l'identifiant unique du doigt<br/>
        float x, float y : la position du doigt, en coordonn&eacute;es pixels (x+ vers le droit, y+ vers le bas)<br/>
        int type : soit MultitouchFramework.TOUCH_EVENT_DOWN, MultitouchFramework.TOUCH_EVENT_MOVE, ou MultitouchFramework.TOUCH_EVENT_UP<br/>
        <br/>
        <br/>



        <br/>
        </td>
  </tr>

</table>

&nbsp;<br/>
&nbsp;<br/>
&nbsp;<br/>
&nbsp;<br/>
&nbsp;<br/>



